RemoteObject.deepSerializedValue

Running test: PrimitiveValue
testing expression: undefined
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : undefined
        }
        [1] : {
            type : undefined
        }
        [2] : {
            type : undefined
        }
        [3] : {
            type : undefined
        }
        [4] : {
            type : undefined
        }
        [5] : {
            type : undefined
        }
    ]
}
testing expression: null
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : null
        }
        [1] : {
            type : null
        }
        [2] : {
            type : null
        }
        [3] : {
            type : null
        }
        [4] : {
            type : null
        }
        [5] : {
            type : null
        }
    ]
}
testing expression: 'foo'
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : string
            value : foo
        }
        [1] : {
            type : string
            value : foo
        }
        [2] : {
            type : string
            value : foo
        }
        [3] : {
            type : string
            value : foo
        }
        [4] : {
            type : string
            value : foo
        }
        [5] : {
            type : string
            value : foo
        }
    ]
}
testing expression: true
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : boolean
            value : true
        }
        [1] : {
            type : boolean
            value : true
        }
        [2] : {
            type : boolean
            value : true
        }
        [3] : {
            type : boolean
            value : true
        }
        [4] : {
            type : boolean
            value : true
        }
        [5] : {
            type : boolean
            value : true
        }
    ]
}
testing expression: false
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : boolean
            value : false
        }
        [1] : {
            type : boolean
            value : false
        }
        [2] : {
            type : boolean
            value : false
        }
        [3] : {
            type : boolean
            value : false
        }
        [4] : {
            type : boolean
            value : false
        }
        [5] : {
            type : boolean
            value : false
        }
    ]
}

Running test: Number
testing expression: 123
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : number
            value : 123
        }
        [1] : {
            type : number
            value : 123
        }
        [2] : {
            type : number
            value : 123
        }
        [3] : {
            type : number
            value : 123
        }
        [4] : {
            type : number
            value : 123
        }
        [5] : {
            type : number
            value : 123
        }
    ]
}
testing expression: 0.56
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : number
            value : 0.56
        }
        [1] : {
            type : number
            value : 0.56
        }
        [2] : {
            type : number
            value : 0.56
        }
        [3] : {
            type : number
            value : 0.56
        }
        [4] : {
            type : number
            value : 0.56
        }
        [5] : {
            type : number
            value : 0.56
        }
    ]
}
testing expression: -0
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : number
            value : -0
        }
        [1] : {
            type : number
            value : -0
        }
        [2] : {
            type : number
            value : -0
        }
        [3] : {
            type : number
            value : -0
        }
        [4] : {
            type : number
            value : -0
        }
        [5] : {
            type : number
            value : -0
        }
    ]
}
testing expression: +Infinity
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : number
            value : Infinity
        }
        [1] : {
            type : number
            value : Infinity
        }
        [2] : {
            type : number
            value : Infinity
        }
        [3] : {
            type : number
            value : Infinity
        }
        [4] : {
            type : number
            value : Infinity
        }
        [5] : {
            type : number
            value : Infinity
        }
    ]
}
testing expression: -Infinity
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : number
            value : -Infinity
        }
        [1] : {
            type : number
            value : -Infinity
        }
        [2] : {
            type : number
            value : -Infinity
        }
        [3] : {
            type : number
            value : -Infinity
        }
        [4] : {
            type : number
            value : -Infinity
        }
        [5] : {
            type : number
            value : -Infinity
        }
    ]
}
testing expression: NaN
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : number
            value : NaN
        }
        [1] : {
            type : number
            value : NaN
        }
        [2] : {
            type : number
            value : NaN
        }
        [3] : {
            type : number
            value : NaN
        }
        [4] : {
            type : number
            value : NaN
        }
        [5] : {
            type : number
            value : NaN
        }
    ]
}

Running test: BigInt
testing expression: 123n
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : bigint
            value : 123
        }
        [1] : {
            type : bigint
            value : 123
        }
        [2] : {
            type : bigint
            value : 123
        }
        [3] : {
            type : bigint
            value : 123
        }
        [4] : {
            type : bigint
            value : 123
        }
        [5] : {
            type : bigint
            value : 123
        }
    ]
}
testing expression: 1234567890n
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : bigint
            value : 1234567890
        }
        [1] : {
            type : bigint
            value : 1234567890
        }
        [2] : {
            type : bigint
            value : 1234567890
        }
        [3] : {
            type : bigint
            value : 1234567890
        }
        [4] : {
            type : bigint
            value : 1234567890
        }
        [5] : {
            type : bigint
            value : 1234567890
        }
    ]
}

Running test: Symbol
testing expression: Symbol('foo')
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : symbol
            weakLocalObjectReference : 1
        }
        [1] : {
            type : symbol
            weakLocalObjectReference : 2
        }
        [2] : {
            type : symbol
            weakLocalObjectReference : 1
        }
        [3] : {
            type : symbol
            weakLocalObjectReference : 2
        }
        [4] : {
            type : symbol
            weakLocalObjectReference : 1
        }
        [5] : {
            type : symbol
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Function
testing expression: function qwe(){}
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : function
            weakLocalObjectReference : 1
        }
        [1] : {
            type : function
            weakLocalObjectReference : 2
        }
        [2] : {
            type : function
            weakLocalObjectReference : 1
        }
        [3] : {
            type : function
            weakLocalObjectReference : 2
        }
        [4] : {
            type : function
            weakLocalObjectReference : 1
        }
        [5] : {
            type : function
            weakLocalObjectReference : 2
        }
    ]
}
testing expression: ()=>{}
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : function
            weakLocalObjectReference : 1
        }
        [1] : {
            type : function
            weakLocalObjectReference : 2
        }
        [2] : {
            type : function
            weakLocalObjectReference : 1
        }
        [3] : {
            type : function
            weakLocalObjectReference : 2
        }
        [4] : {
            type : function
            weakLocalObjectReference : 1
        }
        [5] : {
            type : function
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Array
testing expression: [1,2,undefined]
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : array
            value : [
                [0] : {
                    type : number
                    value : 1
                }
                [1] : {
                    type : number
                    value : 2
                }
                [2] : {
                    type : undefined
                }
            ]
            weakLocalObjectReference : 1
        }
        [1] : {
            type : array
            value : [
                [0] : {
                    type : number
                    value : 1
                }
                [1] : {
                    type : number
                    value : 2
                }
                [2] : {
                    type : undefined
                }
            ]
            weakLocalObjectReference : 2
        }
        [2] : {
            type : array
            weakLocalObjectReference : 1
        }
        [3] : {
            type : array
            weakLocalObjectReference : 2
        }
        [4] : {
            type : array
            weakLocalObjectReference : 1
        }
        [5] : {
            type : array
            weakLocalObjectReference : 2
        }
    ]
}
testing expression: new Array(1,2,undefined)
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : array
            value : [
                [0] : {
                    type : number
                    value : 1
                }
                [1] : {
                    type : number
                    value : 2
                }
                [2] : {
                    type : undefined
                }
            ]
            weakLocalObjectReference : 1
        }
        [1] : {
            type : array
            value : [
                [0] : {
                    type : number
                    value : 1
                }
                [1] : {
                    type : number
                    value : 2
                }
                [2] : {
                    type : undefined
                }
            ]
            weakLocalObjectReference : 2
        }
        [2] : {
            type : array
            weakLocalObjectReference : 1
        }
        [3] : {
            type : array
            weakLocalObjectReference : 2
        }
        [4] : {
            type : array
            weakLocalObjectReference : 1
        }
        [5] : {
            type : array
            weakLocalObjectReference : 2
        }
    ]
}

Running test: RegExp
testing expression: new RegExp('ab+c')
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : regexp
            value : {
                pattern : ab+c
            }
            weakLocalObjectReference : 1
        }
        [1] : {
            type : regexp
            value : {
                pattern : ab+c
            }
            weakLocalObjectReference : 2
        }
        [2] : {
            type : regexp
            weakLocalObjectReference : 1
        }
        [3] : {
            type : regexp
            weakLocalObjectReference : 2
        }
        [4] : {
            type : regexp
            weakLocalObjectReference : 1
        }
        [5] : {
            type : regexp
            weakLocalObjectReference : 2
        }
    ]
}
testing expression: new RegExp('ab+c', 'ig')
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : regexp
            value : {
                flags : gi
                pattern : ab+c
            }
            weakLocalObjectReference : 1
        }
        [1] : {
            type : regexp
            value : {
                flags : gi
                pattern : ab+c
            }
            weakLocalObjectReference : 2
        }
        [2] : {
            type : regexp
            weakLocalObjectReference : 1
        }
        [3] : {
            type : regexp
            weakLocalObjectReference : 2
        }
        [4] : {
            type : regexp
            weakLocalObjectReference : 1
        }
        [5] : {
            type : regexp
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Date
testing expression: new Date('Thu Apr 07 2022 16:17:18 GMT')
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : date
            value : 2022-04-07T16:17:18.000Z
            weakLocalObjectReference : 1
        }
        [1] : {
            type : date
            value : 2022-04-07T16:17:18.000Z
            weakLocalObjectReference : 2
        }
        [2] : {
            type : date
            weakLocalObjectReference : 1
        }
        [3] : {
            type : date
            weakLocalObjectReference : 2
        }
        [4] : {
            type : date
            weakLocalObjectReference : 1
        }
        [5] : {
            type : date
            weakLocalObjectReference : 2
        }
    ]
}
testing expression: new Date('Thu Apr 07 2022 16:17:18 GMT+1100')
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : date
            value : 2022-04-07T05:17:18.000Z
            weakLocalObjectReference : 1
        }
        [1] : {
            type : date
            value : 2022-04-07T05:17:18.000Z
            weakLocalObjectReference : 2
        }
        [2] : {
            type : date
            weakLocalObjectReference : 1
        }
        [3] : {
            type : date
            weakLocalObjectReference : 2
        }
        [4] : {
            type : date
            weakLocalObjectReference : 1
        }
        [5] : {
            type : date
            weakLocalObjectReference : 2
        }
    ]
}
testing expression: new Date('Thu Apr 07 2022 16:17:18 GMT-1100')
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : date
            value : 2022-04-08T03:17:18.000Z
            weakLocalObjectReference : 1
        }
        [1] : {
            type : date
            value : 2022-04-08T03:17:18.000Z
            weakLocalObjectReference : 2
        }
        [2] : {
            type : date
            weakLocalObjectReference : 1
        }
        [3] : {
            type : date
            weakLocalObjectReference : 2
        }
        [4] : {
            type : date
            weakLocalObjectReference : 1
        }
        [5] : {
            type : date
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Error
testing expression: new Error()
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : error
            weakLocalObjectReference : 1
        }
        [1] : {
            type : error
            weakLocalObjectReference : 2
        }
        [2] : {
            type : error
            weakLocalObjectReference : 1
        }
        [3] : {
            type : error
            weakLocalObjectReference : 2
        }
        [4] : {
            type : error
            weakLocalObjectReference : 1
        }
        [5] : {
            type : error
            weakLocalObjectReference : 2
        }
    ]
}
testing expression: new Error('qwe')
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : error
            weakLocalObjectReference : 1
        }
        [1] : {
            type : error
            weakLocalObjectReference : 2
        }
        [2] : {
            type : error
            weakLocalObjectReference : 1
        }
        [3] : {
            type : error
            weakLocalObjectReference : 2
        }
        [4] : {
            type : error
            weakLocalObjectReference : 1
        }
        [5] : {
            type : error
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Map
testing expression: new Map([['keyString1', {valueObject1: 1}], [{keyObject2: 2}, 'valueString2'], ['keyString3', new Array()]])
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : map
            value : [
                [0] : [
                    [0] : keyString1
                    [1] : {
                        type : object
                        value : [
                            [0] : [
                                [0] : valueObject1
                                [1] : {
                                    type : number
                                    value : 1
                                }
                            ]
                        ]
                    }
                ]
                [1] : [
                    [0] : {
                        type : object
                        value : [
                            [0] : [
                                [0] : keyObject2
                                [1] : {
                                    type : number
                                    value : 2
                                }
                            ]
                        ]
                    }
                    [1] : {
                        type : string
                        value : valueString2
                    }
                ]
                [2] : [
                    [0] : keyString3
                    [1] : {
                        type : array
                        value : [
                        ]
                    }
                ]
            ]
            weakLocalObjectReference : 1
        }
        [1] : {
            type : map
            value : [
                [0] : [
                    [0] : keyString1
                    [1] : {
                        type : object
                        value : [
                            [0] : [
                                [0] : valueObject1
                                [1] : {
                                    type : number
                                    value : 1
                                }
                            ]
                        ]
                    }
                ]
                [1] : [
                    [0] : {
                        type : object
                        value : [
                            [0] : [
                                [0] : keyObject2
                                [1] : {
                                    type : number
                                    value : 2
                                }
                            ]
                        ]
                    }
                    [1] : {
                        type : string
                        value : valueString2
                    }
                ]
                [2] : [
                    [0] : keyString3
                    [1] : {
                        type : array
                        value : [
                        ]
                    }
                ]
            ]
            weakLocalObjectReference : 2
        }
        [2] : {
            type : map
            weakLocalObjectReference : 1
        }
        [3] : {
            type : map
            weakLocalObjectReference : 2
        }
        [4] : {
            type : map
            weakLocalObjectReference : 1
        }
        [5] : {
            type : map
            weakLocalObjectReference : 2
        }
    ]
}

Running test: WeakMap
testing expression: new WeakMap([[{valueObject1: 1}, 'keyString1'],[{valueObject2: 2}, 'keyString2']])
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : weakmap
            weakLocalObjectReference : 1
        }
        [1] : {
            type : weakmap
            weakLocalObjectReference : 2
        }
        [2] : {
            type : weakmap
            weakLocalObjectReference : 1
        }
        [3] : {
            type : weakmap
            weakLocalObjectReference : 2
        }
        [4] : {
            type : weakmap
            weakLocalObjectReference : 1
        }
        [5] : {
            type : weakmap
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Set
testing expression: new Set([{valueObject1: 1}, 'valueString2', new Array(), undefined])
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : set
            value : [
                [0] : {
                    type : object
                    value : [
                        [0] : [
                            [0] : valueObject1
                            [1] : {
                                type : number
                                value : 1
                            }
                        ]
                    ]
                }
                [1] : {
                    type : string
                    value : valueString2
                }
                [2] : {
                    type : array
                    value : [
                    ]
                }
                [3] : {
                    type : undefined
                }
            ]
            weakLocalObjectReference : 1
        }
        [1] : {
            type : set
            value : [
                [0] : {
                    type : object
                    value : [
                        [0] : [
                            [0] : valueObject1
                            [1] : {
                                type : number
                                value : 1
                            }
                        ]
                    ]
                }
                [1] : {
                    type : string
                    value : valueString2
                }
                [2] : {
                    type : array
                    value : [
                    ]
                }
                [3] : {
                    type : undefined
                }
            ]
            weakLocalObjectReference : 2
        }
        [2] : {
            type : set
            weakLocalObjectReference : 1
        }
        [3] : {
            type : set
            weakLocalObjectReference : 2
        }
        [4] : {
            type : set
            weakLocalObjectReference : 1
        }
        [5] : {
            type : set
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Weakset
testing expression: new WeakSet([{valueObject1: 1}, {valueObject2: 2}])
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : weakset
            weakLocalObjectReference : 1
        }
        [1] : {
            type : weakset
            weakLocalObjectReference : 2
        }
        [2] : {
            type : weakset
            weakLocalObjectReference : 1
        }
        [3] : {
            type : weakset
            weakLocalObjectReference : 2
        }
        [4] : {
            type : weakset
            weakLocalObjectReference : 1
        }
        [5] : {
            type : weakset
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Proxy
testing expression: new Proxy({}, ()=>{})
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : proxy
            weakLocalObjectReference : 1
        }
        [1] : {
            type : proxy
            weakLocalObjectReference : 2
        }
        [2] : {
            type : proxy
            weakLocalObjectReference : 1
        }
        [3] : {
            type : proxy
            weakLocalObjectReference : 2
        }
        [4] : {
            type : proxy
            weakLocalObjectReference : 1
        }
        [5] : {
            type : proxy
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Promise
testing expression: new Promise(()=>{})
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : promise
            weakLocalObjectReference : 1
        }
        [1] : {
            type : promise
            weakLocalObjectReference : 2
        }
        [2] : {
            type : promise
            weakLocalObjectReference : 1
        }
        [3] : {
            type : promise
            weakLocalObjectReference : 2
        }
        [4] : {
            type : promise
            weakLocalObjectReference : 1
        }
        [5] : {
            type : promise
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Typedarray
testing expression: new Uint16Array()
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : typedarray
            weakLocalObjectReference : 1
        }
        [1] : {
            type : typedarray
            weakLocalObjectReference : 2
        }
        [2] : {
            type : typedarray
            weakLocalObjectReference : 1
        }
        [3] : {
            type : typedarray
            weakLocalObjectReference : 2
        }
        [4] : {
            type : typedarray
            weakLocalObjectReference : 1
        }
        [5] : {
            type : typedarray
            weakLocalObjectReference : 2
        }
    ]
}

Running test: ArrayBuffer
testing expression: new ArrayBuffer()
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : arraybuffer
            weakLocalObjectReference : 1
        }
        [1] : {
            type : arraybuffer
            weakLocalObjectReference : 2
        }
        [2] : {
            type : arraybuffer
            weakLocalObjectReference : 1
        }
        [3] : {
            type : arraybuffer
            weakLocalObjectReference : 2
        }
        [4] : {
            type : arraybuffer
            weakLocalObjectReference : 1
        }
        [5] : {
            type : arraybuffer
            weakLocalObjectReference : 2
        }
    ]
}

Running test: Duplicate
testing expression: (()=>{const foo={a: []}; const bar=[1,2]; const result={1: foo, 2: foo, 3: bar, 4: bar}; result.self=result; return result; })()
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : object
            value : [
                [0] : [
                    [0] : 1
                    [1] : {
                        type : object
                        value : [
                            [0] : [
                                [0] : a
                                [1] : {
                                    type : array
                                    value : [
                                    ]
                                }
                            ]
                        ]
                        weakLocalObjectReference : 1
                    }
                ]
                [1] : [
                    [0] : 2
                    [1] : {
                        type : object
                        weakLocalObjectReference : 1
                    }
                ]
                [2] : [
                    [0] : 3
                    [1] : {
                        type : array
                        value : [
                            [0] : {
                                type : number
                                value : 1
                            }
                            [1] : {
                                type : number
                                value : 2
                            }
                        ]
                        weakLocalObjectReference : 2
                    }
                ]
                [3] : [
                    [0] : 4
                    [1] : {
                        type : array
                        weakLocalObjectReference : 2
                    }
                ]
                [4] : [
                    [0] : self
                    [1] : {
                        type : object
                        weakLocalObjectReference : 3
                    }
                ]
            ]
            weakLocalObjectReference : 3
        }
        [1] : {
            type : object
            value : [
                [0] : [
                    [0] : 1
                    [1] : {
                        type : object
                        value : [
                            [0] : [
                                [0] : a
                                [1] : {
                                    type : array
                                    value : [
                                    ]
                                }
                            ]
                        ]
                        weakLocalObjectReference : 4
                    }
                ]
                [1] : [
                    [0] : 2
                    [1] : {
                        type : object
                        weakLocalObjectReference : 4
                    }
                ]
                [2] : [
                    [0] : 3
                    [1] : {
                        type : array
                        value : [
                            [0] : {
                                type : number
                                value : 1
                            }
                            [1] : {
                                type : number
                                value : 2
                            }
                        ]
                        weakLocalObjectReference : 5
                    }
                ]
                [3] : [
                    [0] : 4
                    [1] : {
                        type : array
                        weakLocalObjectReference : 5
                    }
                ]
                [4] : [
                    [0] : self
                    [1] : {
                        type : object
                        weakLocalObjectReference : 6
                    }
                ]
            ]
            weakLocalObjectReference : 6
        }
        [2] : {
            type : object
            weakLocalObjectReference : 3
        }
        [3] : {
            type : object
            weakLocalObjectReference : 6
        }
        [4] : {
            type : object
            weakLocalObjectReference : 3
        }
        [5] : {
            type : object
            weakLocalObjectReference : 6
        }
    ]
}

Running test: Object
testing expression: {nullKey: null, stringKey: 'foo',boolKey: true,numberKey: 123,bigintKey: 123n,symbolKey: Symbol('foo'),functionKey: () => {},arrayKey:[1],undefinedKey:undefined}
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : object
            value : [
                [0] : [
                    [0] : nullKey
                    [1] : {
                        type : null
                    }
                ]
                [1] : [
                    [0] : stringKey
                    [1] : {
                        type : string
                        value : foo
                    }
                ]
                [2] : [
                    [0] : boolKey
                    [1] : {
                        type : boolean
                        value : true
                    }
                ]
                [3] : [
                    [0] : numberKey
                    [1] : {
                        type : number
                        value : 123
                    }
                ]
                [4] : [
                    [0] : bigintKey
                    [1] : {
                        type : bigint
                        value : 123
                    }
                ]
                [5] : [
                    [0] : symbolKey
                    [1] : {
                        type : symbol
                    }
                ]
                [6] : [
                    [0] : functionKey
                    [1] : {
                        type : function
                    }
                ]
                [7] : [
                    [0] : arrayKey
                    [1] : {
                        type : array
                        value : [
                            [0] : {
                                type : number
                                value : 1
                            }
                        ]
                    }
                ]
                [8] : [
                    [0] : undefinedKey
                    [1] : {
                        type : undefined
                    }
                ]
            ]
            weakLocalObjectReference : 1
        }
        [1] : {
            type : object
            value : [
                [0] : [
                    [0] : nullKey
                    [1] : {
                        type : null
                    }
                ]
                [1] : [
                    [0] : stringKey
                    [1] : {
                        type : string
                        value : foo
                    }
                ]
                [2] : [
                    [0] : boolKey
                    [1] : {
                        type : boolean
                        value : true
                    }
                ]
                [3] : [
                    [0] : numberKey
                    [1] : {
                        type : number
                        value : 123
                    }
                ]
                [4] : [
                    [0] : bigintKey
                    [1] : {
                        type : bigint
                        value : 123
                    }
                ]
                [5] : [
                    [0] : symbolKey
                    [1] : {
                        type : symbol
                    }
                ]
                [6] : [
                    [0] : functionKey
                    [1] : {
                        type : function
                    }
                ]
                [7] : [
                    [0] : arrayKey
                    [1] : {
                        type : array
                        value : [
                            [0] : {
                                type : number
                                value : 1
                            }
                        ]
                    }
                ]
                [8] : [
                    [0] : undefinedKey
                    [1] : {
                        type : undefined
                    }
                ]
            ]
            weakLocalObjectReference : 2
        }
        [2] : {
            type : object
            weakLocalObjectReference : 1
        }
        [3] : {
            type : object
            weakLocalObjectReference : 2
        }
        [4] : {
            type : object
            weakLocalObjectReference : 1
        }
        [5] : {
            type : object
            weakLocalObjectReference : 2
        }
    ]
}
testing expression: {key_level_1: {key_level_2: {key_level_3: 'value_level_3'}}}
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : object
            value : [
                [0] : [
                    [0] : key_level_1
                    [1] : {
                        type : object
                        value : [
                            [0] : [
                                [0] : key_level_2
                                [1] : {
                                    type : object
                                    value : [
                                        [0] : [
                                            [0] : key_level_3
                                            [1] : {
                                                type : string
                                                value : value_level_3
                                            }
                                        ]
                                    ]
                                }
                            ]
                        ]
                    }
                ]
            ]
            weakLocalObjectReference : 1
        }
        [1] : {
            type : object
            value : [
                [0] : [
                    [0] : key_level_1
                    [1] : {
                        type : object
                        value : [
                            [0] : [
                                [0] : key_level_2
                                [1] : {
                                    type : object
                                    value : [
                                        [0] : [
                                            [0] : key_level_3
                                            [1] : {
                                                type : string
                                                value : value_level_3
                                            }
                                        ]
                                    ]
                                }
                            ]
                        ]
                    }
                ]
            ]
            weakLocalObjectReference : 2
        }
        [2] : {
            type : object
            weakLocalObjectReference : 1
        }
        [3] : {
            type : object
            weakLocalObjectReference : 2
        }
        [4] : {
            type : object
            weakLocalObjectReference : 1
        }
        [5] : {
            type : object
            weakLocalObjectReference : 2
        }
    ]
}
